home *** CD-ROM | disk | FTP | other *** search
/ Champak 138 / Volume 138 Aug 19 2011 - Damaged.iso / Games / shadez.swf / scripts / Local / Game / Thing / CThingSprite.as < prev    next >
Encoding:
Text File  |  2011-08-19  |  19.1 KB  |  654 lines
  1. package Local.Game.Thing
  2. {
  3.    import Local.*;
  4.    import Local.Game.*;
  5.    import Local.Game.World.*;
  6.    import STC9.System.*;
  7.    import flash.display.*;
  8.    import flash.events.*;
  9.    import flash.filters.*;
  10.    import flash.geom.*;
  11.    
  12.    public class CThingSprite extends CThingMain
  13.    {
  14.       
  15.       public static var mMousePosition:Point;
  16.       
  17.       internal static var mcMouseScratch:MovieClip = new MovieClip();
  18.       
  19.       public static var mAnimationCollection:Object;
  20.       
  21.       internal static var mCTSelected:ColorTransform = new ColorTransform(1,1,1,1,128,0,0,0);
  22.       
  23.       public static const mSpriteScalar:Number = 0.3;
  24.       
  25.       public static const mMatrixScalar:Matrix = new Matrix(mSpriteScalar,0,0,mSpriteScalar,0,0);
  26.       
  27.       internal static var mcDrawScratch:MovieClip = new MovieClip();
  28.       
  29.       public static var bPlane:BitmapData;
  30.       
  31.       internal static var mCTNormal:ColorTransform = new ColorTransform(1,1,1,1,0,0,0,0);
  32.       
  33.       public static var mSpriteDump:Boolean = false;
  34.       
  35.       internal static var mCTHilight:ColorTransform = new ColorTransform(1,1,1,1,0,128,0,0);
  36.       
  37.       internal static var mCTFlash:ColorTransform = new ColorTransform(1,1,1,1,0,0,0,0);
  38.        
  39.       
  40.       private var _SelectionFlash:int;
  41.       
  42.       private var _MouseSelected:Boolean;
  43.       
  44.       public var mDrawMatrix:Matrix;
  45.       
  46.       public var mAnimationLength:int;
  47.       
  48.       private var _MouseOver:Boolean;
  49.       
  50.       private var _ColorTransform:ColorTransform;
  51.       
  52.       public var mSprite:CSpriteFrame;
  53.       
  54.       public var mAnimation:Array;
  55.       
  56.       public function CThingSprite()
  57.       {
  58.          super();
  59.          mAnimationFrame = 0;
  60.       }
  61.       
  62.       private static function CTClone(param1:ColorTransform) : ColorTransform
  63.       {
  64.          return new ColorTransform(param1.redMultiplier,param1.greenMultiplier,param1.blueMultiplier,param1.alphaMultiplier,param1.redOffset,param1.greenOffset,param1.blueOffset,param1.alphaOffset);
  65.       }
  66.       
  67.       public function AddAnimation(param1:String, param2:Class, param3:String, param4:Boolean = true, param5:Boolean = false) : void
  68.       {
  69.          var _loc6_:MovieClip = null;
  70.          var _loc7_:MovieClip = null;
  71.          var _loc8_:* = 0;
  72.          var _loc9_:* = 0;
  73.          if(true)
  74.          {
  75.             if(!(mAnimation = AnimationExists(param1)))
  76.             {
  77.                addr31:
  78.                _loc6_ = new param2();
  79.                mAnimation = new Array();
  80.                if(_loc7_ = FindTag(_loc6_,"animation"))
  81.                {
  82.                   _loc6_.addEventListener(Event.ENTER_FRAME,FillFrames);
  83.                   _loc6_.mAnimation = mAnimation;
  84.                   _loc6_.tagAnimation = _loc7_;
  85.                   _loc6_.includeLastFrame = param4;
  86.                   _loc6_.addSprite = param3;
  87.                   _loc6_.frameIndex = 1;
  88.                   _loc6_.mThing = this;
  89.                   _loc6_.stop();
  90.                   _loc6_.tagAnimation.stop();
  91.                }
  92.                ┬º┬ºpush(1);
  93.                if(true)
  94.                {
  95.                   _loc8_ = ┬º┬ºpop();
  96.                   ┬º┬ºpush(int(_loc6_.totalFrames - (param4 ? 0 : 1)));
  97.                }
  98.                _loc9_ = ┬º┬ºpop();
  99.                while(_loc8_ <= _loc9_)
  100.                {
  101.                   _loc6_.gotoAndStop(_loc8_);
  102.                   this[param3](_loc6_);
  103.                   AddFrame(_loc8_ - 1);
  104.                   _loc8_++;
  105.                }
  106.                mAnimationCollection[mType][param1] = mAnimation;
  107.             }
  108.             SetAnimation(param1);
  109.             if(true)
  110.             {
  111.                GetAnimationFrame();
  112.                CProfiler.AddDebug("mem animations",String(Math.ceil(mMemSize / 1000)) + "kb");
  113.             }
  114.             return;
  115.          }
  116.          ┬º┬ºgoto(addr31);
  117.       }
  118.       
  119.       public function AddSprite_Line(param1:Number, param2:Number, param3:Number, param4:Number, param5:uint, param6:Number) : void
  120.       {
  121.          var _loc7_:Graphics = null;
  122.          (_loc7_ = mcDrawScratch.graphics).clear();
  123.          _loc7_.lineStyle(param6,param5 & 16777215,(param5 >>> 24) / 255);
  124.          _loc7_.moveTo(param1,param2);
  125.          _loc7_.lineTo(param3,param4);
  126.          mSprite = CSpriteFrame.asMovieClip(mcDrawScratch);
  127.          ┬º┬ºpush(mSprite);
  128.          if(true)
  129.          {
  130.             ┬º┬ºpop().mCanDispose = true;
  131.             mSprite.ApplyFilter(new GlowFilter(16777215,1,2,2,1,1));
  132.             ┬º┬ºpush(mSprite);
  133.          }
  134.          ┬º┬ºpop().CaptureMovieClip();
  135.       }
  136.       
  137.       public function DrawSpriteQ() : void
  138.       {
  139.          if(mInvisible)
  140.          {
  141.             return;
  142.          }
  143.          bPlane.copyPixels(mSprite.mBMD,mSprite.mBMD.rect,GetDrawPosition().add(mSprite.mDisplacement),null,null,true);
  144.       }
  145.       
  146.       private function FillFrames(param1:Event) : void
  147.       {
  148.          var _loc2_:MovieClip = null;
  149.          _loc2_ = MovieClip(param1.currentTarget);
  150.          if(_loc2_.frameIndex == 1)
  151.          {
  152.             _loc2_.mAnimation.length = 0;
  153.          }
  154.          _loc2_.tagAnimation.gotoAndStop(_loc2_.frameIndex);
  155.          _loc2_.mThing[_loc2_.addSprite](_loc2_);
  156.          _loc2_.mThing.AddFrame(_loc2_.frameIndex - 1);
  157.          var _loc3_:*;
  158.          var _loc4_:* = (_loc3_ = _loc2_).frameIndex + 1;
  159.          if(true)
  160.          {
  161.             _loc3_.frameIndex = _loc4_;
  162.          }
  163.          if(_loc2_.frameIndex > _loc2_.tagAnimation.totalFrames - (!!_loc2_.includeLastFrame ? 0 : 1))
  164.          {
  165.             _loc2_.removeEventListener(Event.ENTER_FRAME,FillFrames);
  166.          }
  167.       }
  168.       
  169.       public function set mColorTransform(param1:ColorTransform) : void
  170.       {
  171.          var _loc2_:* = undefined;
  172.          _ColorTransform = param1;
  173.          for each(_loc2_ in mChildren)
  174.          {
  175.             if(true)
  176.             {
  177.                _loc2_.mColorTransform = param1;
  178.             }
  179.          }
  180.       }
  181.       
  182.       public function get mMemSize() : uint
  183.       {
  184.          var _loc1_:uint = 0;
  185.          var _loc2_:Object = null;
  186.          var _loc3_:Object = null;
  187.          var _loc4_:CSpriteFrame = null;
  188.          if(true)
  189.          {
  190.             ┬º┬ºpush(0);
  191.             if(true)
  192.             {
  193.                _loc1_ = ┬º┬ºpop();
  194.                addr28:
  195.                ┬º┬ºpush(0);
  196.             }
  197.             for each(_loc2_ in mAnimationCollection)
  198.             {
  199.                var _loc7_:int = 0;
  200.                if(true)
  201.                {
  202.                   for each(_loc3_ in _loc2_)
  203.                   {
  204.                      if(true)
  205.                      {
  206.                         for each(_loc4_ in _loc3_)
  207.                         {
  208.                            if(true)
  209.                            {
  210.                               _loc1_ += _loc4_.mMemSize;
  211.                            }
  212.                         }
  213.                      }
  214.                   }
  215.                }
  216.             }
  217.             return _loc1_;
  218.          }
  219.          ┬º┬ºgoto(addr28);
  220.       }
  221.       
  222.       public function AddSprite_Scale(param1:MovieClip) : void
  223.       {
  224.          mSprite = CSpriteFrame.asMovieClip(param1);
  225.          ┬º┬ºpush(mSprite);
  226.          if(true)
  227.          {
  228.             ┬º┬ºpop().ApplyFilter(new GlowFilter(2105376,1,2,2,1,1));
  229.             mSprite.ApplyScaleMatrix(mMatrixScalar);
  230.             ┬º┬ºpush(mSprite);
  231.          }
  232.          ┬º┬ºpop().CaptureMovieClip();
  233.       }
  234.       
  235.       public function GetObjectPosition(param1:String, param2:CPosition = null) : CPosition
  236.       {
  237.          return CPosition.CLONE(OrientatePoint(mSprite.mObjects[param1].mPosition.clone(),param2));
  238.       }
  239.       
  240.       public function AddSprite_Blue(param1:MovieClip) : void
  241.       {
  242.          if(true)
  243.          {
  244.             mSprite = CSpriteFrame.asMovieClip(param1);
  245.             if(true)
  246.             {
  247.                mSprite.ApplyFilter(new GlowFilter(255,1,2,2,1,1));
  248.                if(true)
  249.                {
  250.                   mSprite.ApplyBlue();
  251.                }
  252.                mSprite.ApplyScaleMatrix(mMatrixScalar);
  253.             }
  254.             mSprite.CaptureMovieClip();
  255.          }
  256.       }
  257.       
  258.       public function set mMouseOver(param1:Boolean) : void
  259.       {
  260.          if(true)
  261.          {
  262.             if(param1 != _MouseOver)
  263.             {
  264.                _MouseOver = param1;
  265.             }
  266.          }
  267.       }
  268.       
  269.       public function AddAnimationAsFrames(param1:String, param2:Array) : void
  270.       {
  271.          var _loc3_:Object = null;
  272.          if(!(mAnimation = AnimationExists(param1)))
  273.          {
  274.             mAnimation = new Array();
  275.             for each(_loc3_ in param2)
  276.             {
  277.                mSprite = CSpriteFrame.asFrame(_loc3_);
  278.                AddFrame(mAnimation.length);
  279.             }
  280.             mAnimationCollection[mType][param1] = mAnimation;
  281.          }
  282.          SetAnimation(param1);
  283.          GetAnimationFrame();
  284.       }
  285.       
  286.       public function SelectionFlash_Init() : void
  287.       {
  288.          if(true)
  289.          {
  290.             _SelectionFlash = mGameTick;
  291.             mColorTransform = new ColorTransform();
  292.          }
  293.       }
  294.       
  295.       private function AddSprite(param1:MovieClip, param2:Boolean, param3:GlowFilter, param4:Boolean) : void
  296.       {
  297.          mSprite = CSpriteFrame.asMovieClip(param1);
  298.          if(param3)
  299.          {
  300.             mSprite.ApplyFilter(param3);
  301.          }
  302.          if(param2)
  303.          {
  304.             mSprite.ApplyBlacken();
  305.          }
  306.          if(param4)
  307.          {
  308.             mSprite.ApplyScaleMatrix(mMatrixScalar);
  309.          }
  310.          mSprite.CaptureMovieClip();
  311.       }
  312.       
  313.       public function AddSprite_Normal(param1:MovieClip) : void
  314.       {
  315.          mSprite = CSpriteFrame.asMovieClip(param1);
  316.          mSprite.CaptureMovieClip();
  317.       }
  318.       
  319.       public function Explode(param1:Point = null) : void
  320.       {
  321.          if(mDrawn && !mReachedObjective && !CGlobal.mFastRender)
  322.          {
  323.             mLandscape.AddExplodeBMD(mSprite.mBMD,mDrawMatrix,param1);
  324.          }
  325.       }
  326.       
  327.       public function ExplodeSmall(param1:Point = null) : void
  328.       {
  329.          ┬º┬ºpush(mDrawn);
  330.          ┬º┬ºpush(mDrawn);
  331.          if(true)
  332.          {
  333.             if(┬º┬ºpop())
  334.             {
  335.                ┬º┬ºpop();
  336.                ┬º┬ºpush(!mReachedObjective);
  337.             }
  338.             ┬º┬ºpush(┬º┬ºpop());
  339.          }
  340.          if(┬º┬ºpop())
  341.          {
  342.             ┬º┬ºpop();
  343.             ┬º┬ºpush(!CGlobal.mFastRender);
  344.          }
  345.          if(┬º┬ºpop())
  346.          {
  347.             mLandscape.AddExplodeBMD(mSprite.mBMD,mDrawMatrix,param1,3);
  348.          }
  349.       }
  350.       
  351.       public function AnimationExists(param1:String) : Array
  352.       {
  353.          if(!mAnimationCollection)
  354.          {
  355.             mAnimationCollection = new Object();
  356.          }
  357.          if(!mAnimationCollection[mType])
  358.          {
  359.             mAnimationCollection[mType] = new Object();
  360.          }
  361.          return mAnimationCollection[mType][param1];
  362.       }
  363.       
  364.       public function get mMouseSelected() : Boolean
  365.       {
  366.          return _MouseSelected;
  367.       }
  368.       
  369.       public function FindTag(param1:MovieClip, param2:String) : MovieClip
  370.       {
  371.          var _loc3_:MovieClip = null;
  372.          var _loc4_:int = 0;
  373.          var _loc5_:DisplayObject = null;
  374.          var _loc6_:String = null;
  375.          var _loc7_:String = null;
  376.          if(true)
  377.          {
  378.             _loc4_ = 0;
  379.          }
  380.          while(_loc4_ < param1.numChildren)
  381.          {
  382.             _loc6_ = (_loc5_ = param1.getChildAt(_loc4_)).name;
  383.             _loc7_ = String(_loc5_);
  384.             if(_loc5_.hasOwnProperty("totalFrames"))
  385.             {
  386.                if(_loc5_.name == param2)
  387.                {
  388.                   return MovieClip(_loc5_);
  389.                }
  390.                if((_loc3_ = FindTag(MovieClip(_loc5_),param2)) != null)
  391.                {
  392.                   return _loc3_;
  393.                }
  394.             }
  395.             _loc4_++;
  396.          }
  397.          return null;
  398.       }
  399.       
  400.       public function AddSprite_Black(param1:MovieClip) : void
  401.       {
  402.          mSprite = CSpriteFrame.asMovieClip(param1);
  403.          mSprite.ApplyFilter(new GlowFilter(0,1,2,2,1,1));
  404.          mSprite.ApplyBlacken();
  405.          mSprite.ApplyScaleMatrix(mMatrixScalar);
  406.          mSprite.CaptureMovieClip();
  407.          mSprite.PostFilter(new BevelFilter(0.5,115,16758816,1,0,1,1,1,0.25,3,"inner"));
  408.       }
  409.       
  410.       public function SelectionFlash_Draw() : void
  411.       {
  412.          var _loc1_:Number = NaN;
  413.          var _loc2_:int = 0;
  414.          ┬º┬ºpush(_SelectionFlash);
  415.          if(true)
  416.          {
  417.             if(!┬º┬ºpop())
  418.             {
  419.                return;
  420.             }
  421.             _loc1_ = Math.floor(SECONDS * 0.5);
  422.             _loc2_ = mGameTick - _SelectionFlash;
  423.             ┬º┬ºpush(_loc2_);
  424.          }
  425.          if(┬º┬ºpop() > _loc1_)
  426.          {
  427.             _SelectionFlash = 0;
  428.             mColorTransform = null;
  429.             return;
  430.          }
  431.          mColorTransform.alphaMultiplier = !!(_loc2_ % 2) ? _loc2_ / _loc1_ * 0.7 : 1;
  432.       }
  433.       
  434.       public function GetAnimationFrameQ() : CSpriteFrame
  435.       {
  436.          return mSprite = mAnimation[Math.floor(mAnimationFrame * mAnimationLength)];
  437.       }
  438.       
  439.       public function get mColorTransform() : ColorTransform
  440.       {
  441.          return _ColorTransform;
  442.       }
  443.       
  444.       public function GetAnimationFrame() : CSpriteFrame
  445.       {
  446.          return mSprite = mAnimation[Math.floor(mAnimationFrame * mAnimationLength) % mAnimationLength];
  447.       }
  448.       
  449.       public function SetCollisionBySprite(param1:CSpriteFrame) : void
  450.       {
  451.          var _loc2_:Object = null;
  452.          var _loc3_:Array = null;
  453.          var _loc4_:int = 0;
  454.          _loc3_ = new Array();
  455.          if(!param1.mObjects["cline1"])
  456.          {
  457.             return;
  458.          }
  459.          _loc4_ = 1;
  460.          while(true)
  461.          {
  462.             if(_loc4_ >= 10000)
  463.             {
  464.                if(true)
  465.                {
  466.                   break;
  467.                }
  468.                mCollide = new CTCollideShape(this,_loc3_,(_loc2_ = param1.mObjects["mid"]) != null ? new CPosition(_loc2_.mPosition.x,_loc2_.mPosition.y) : new CPosition());
  469.                return;
  470.                addr70:
  471.             }
  472.             if((_loc2_ = param1.mObjects["cline" + _loc4_]) == null)
  473.             {
  474.                break;
  475.             }
  476.             _loc3_.push(new CPosition(_loc2_.mPosition.x,_loc2_.mPosition.y));
  477.             _loc4_++;
  478.          }
  479.          ┬º┬ºgoto(addr70);
  480.       }
  481.       
  482.       public function get mMouseOver() : Boolean
  483.       {
  484.          return _MouseOver;
  485.       }
  486.       
  487.       public function AddSprite_White(param1:MovieClip) : void
  488.       {
  489.          if(true)
  490.          {
  491.             mSprite = CSpriteFrame.asMovieClip(param1);
  492.             if(true)
  493.             {
  494.                mSprite.ApplyFilter(new GlowFilter(16777215,1,2,2,1,1));
  495.                mSprite.ApplyScaleMatrix(mMatrixScalar);
  496.             }
  497.             mSprite.CaptureMovieClip();
  498.          }
  499.       }
  500.       
  501.       public function AddSprite_Red(param1:MovieClip) : void
  502.       {
  503.          if(true)
  504.          {
  505.             mSprite = CSpriteFrame.asMovieClip(param1);
  506.             if(true)
  507.             {
  508.                ┬º┬ºpush(mSprite);
  509.                if(true)
  510.                {
  511.                   ┬º┬ºpop().ApplyFilter(new GlowFilter(16711680,1,2,2,1,1));
  512.                   if(true)
  513.                   {
  514.                      ┬º┬ºpush(mSprite);
  515.                      if(true)
  516.                      {
  517.                         ┬º┬ºpop().ApplyReden();
  518.                         addr43:
  519.                         ┬º┬ºpush(mSprite);
  520.                      }
  521.                      ┬º┬ºpop().ApplyScaleMatrix(mMatrixScalar);
  522.                      addr54:
  523.                      mSprite.CaptureMovieClip();
  524.                      return;
  525.                      addr53:
  526.                   }
  527.                   ┬º┬ºgoto(addr43);
  528.                }
  529.                ┬º┬ºgoto(addr54);
  530.             }
  531.             ┬º┬ºgoto(addr53);
  532.          }
  533.          ┬º┬ºgoto(addr54);
  534.       }
  535.       
  536.       public function SetAnimation(param1:String) : void
  537.       {
  538.          mAnimation = mAnimationCollection[mType][param1];
  539.          mAnimationLength = mAnimation.length;
  540.       }
  541.       
  542.       override public function Draw() : void
  543.       {
  544.          super.Draw();
  545.       }
  546.       
  547.       private function AddFrame(param1:int) : void
  548.       {
  549.          if(true)
  550.          {
  551.             mAnimation.push(mSprite);
  552.             mSprite.mFrameIndex = param1;
  553.          }
  554.       }
  555.       
  556.       public function DrawSprite(param1:Matrix) : void
  557.       {
  558.          var _loc2_:Matrix = null;
  559.          var _loc3_:Point = null;
  560.          if(mInvisible)
  561.          {
  562.             return;
  563.          }
  564.          mDrawMatrix = mSprite.mDispMatrix.clone();
  565.          mDrawMatrix.concat(param1);
  566.          mDrawMatrix.tx += mPosition.x;
  567.          mDrawMatrix.ty += mPosition.y;
  568.          if(mSelectable)
  569.          {
  570.             _loc2_ = mDrawMatrix.clone();
  571.             if(true)
  572.             {
  573.                _loc2_.invert();
  574.             }
  575.             _loc3_ = _loc2_.transformPoint(mMousePosition);
  576.             if(mSprite.mBMD.getPixel32(_loc3_.x,_loc3_.y) > 16777215)
  577.             {
  578.                mWorld.mMouse.mOverThing = this;
  579.             }
  580.             SelectionFlash_Draw();
  581.          }
  582.          if(param1.a == 1 && param1.d == 1)
  583.          {
  584.             DrawSpriteQ();
  585.             return;
  586.          }
  587.          mDrawMatrix.tx -= mLandscape.mDrawPosition.x;
  588.          mDrawMatrix.ty -= mLandscape.mDrawPosition.y;
  589.          bPlane.draw(mSprite.mBMD,mDrawMatrix,mColorTransform,null,null,true);
  590.       }
  591.       
  592.       public function Animate1() : void
  593.       {
  594.          if(true)
  595.          {
  596.             mAnimationFrame += 1 / mAnimation.length;
  597.          }
  598.       }
  599.       
  600.       public function set mMouseSelected(param1:Boolean) : void
  601.       {
  602.          if(param1 != _MouseSelected)
  603.          {
  604.             _MouseSelected = param1;
  605.             if(_MouseSelected)
  606.             {
  607.                SelectionFlash_Init();
  608.             }
  609.          }
  610.       }
  611.       
  612.       public function AddSprite_Black2(param1:MovieClip) : void
  613.       {
  614.          mSprite = CSpriteFrame.asMovieClip(param1);
  615.          ┬º┬ºpush(mSprite);
  616.          if(true)
  617.          {
  618.             ┬º┬ºpop().ApplyFilter(new GlowFilter(0,1,2,2,1,1));
  619.             ┬º┬ºpush(mSprite);
  620.             if(true)
  621.             {
  622.                ┬º┬ºpop().ApplyScaleMatrix(mMatrixScalar);
  623.                ┬º┬ºpush(mSprite);
  624.             }
  625.             ┬º┬ºpop().CaptureMovieClip();
  626.             ┬º┬ºpush(mSprite);
  627.          }
  628.          ┬º┬ºpop().PostFilter(new BevelFilter(0.5,115,16758816,1,0,1,1,1,0.25,3,"inner"));
  629.       }
  630.       
  631.       override public function Dispose() : void
  632.       {
  633.          if(mDisposed)
  634.          {
  635.             return;
  636.          }
  637.          super.Dispose();
  638.          ┬º┬ºpush(mSprite);
  639.          if(true)
  640.          {
  641.             if(!┬º┬ºpop())
  642.             {
  643.                return;
  644.             }
  645.             ┬º┬ºpush(mSprite);
  646.          }
  647.          if(┬º┬ºpop().Dispose())
  648.          {
  649.             mSprite = null;
  650.          }
  651.       }
  652.    }
  653. }
  654.